Alternatives aux Enums TypeScript : Assertions de constantes vs. Types d'union

L'enum de TypeScript est une fonctionnalité puissante pour définir un ensemble de constantes nommées. Cependant, ce n'est pas toujours le meilleur choix. Cet article explore les alternatives aux enums, spécifiquement les assertions de constantes et les types d'union, et fournit des conseils sur le moment d'utiliser chacune pour une qualité de code, une maintenabilité et une performance optimales. Nous examinerons les nuances de chaque approche, en offrant des exemples pratiques et en abordant les préoccupations courantes.

Comprendre les Enums TypeScript

Avant d'explorer les alternatives, passons rapidement en revue les enums TypeScript. Un enum est une manière de définir un ensemble de constantes numériques nommées. Par défaut, le premier membre d'un enum se voit attribuer la valeur 0, et les membres suivants sont incrémentés de 1.

            
enum Status {
  Pending,
  InProgress,
  Completed,
  Rejected,
}

const currentStatus: Status = Status.InProgress; // currentStatus sera 1

            

              
                Copy
              
            
          

Vous pouvez également attribuer explicitement des valeurs aux membres d'un enum :

            
enum HTTPStatus {
  OK = 200,
  BadRequest = 400,
  Unauthorized = 401,
  Forbidden = 403,
  NotFound = 404,
}

const serverResponse: HTTPStatus = HTTPStatus.OK; // serverResponse sera 200

            

              
                Copy
              
            
          

Avantages des Enums

• Lisibilité : Les enums améliorent la lisibilité du code en fournissant des noms significatifs pour les constantes numériques.
• Sécurité de type : Ils garantissent la sécurité de type en restreignant les valeurs aux membres d'enum définis.
• Autocomplétion : Les IDEs offrent des suggestions d'autocomplétion pour les membres d'enum, réduisant ainsi les erreurs.

Inconvénients des Enums

• Surcharge d'exécution : Les enums sont compilés en objets JavaScript, ce qui peut introduire une surcharge d'exécution, en particulier dans les grandes applications.
• Mutation : Les enums sont mutables par défaut. Bien que TypeScript fournisse const enum pour empêcher la mutation, cela a des limitations.
• Mappage inversé : Les enums numériques créent un mappage inversé (par exemple, Status[1] retourne "InProgress"), ce qui est souvent inutile et peut augmenter la taille du bundle.

Alternative 1 : Assertions de constantes

Les assertions de constantes offrent un moyen de créer des structures de données immuables et en lecture seule. Elles peuvent être utilisées comme alternative aux enums dans de nombreux cas, en particulier lorsque vous avez besoin d'un ensemble simple de constantes de type chaîne ou numérique.

            
const Status = {
  Pending: 'pending',
  InProgress: 'in_progress',
  Completed: 'completed',
  Rejected: 'rejected',
} as const;

// Typescript infère le type suivant :
// {
//    readonly Pending: "pending";
//    readonly InProgress: "in_progress";
//    readonly Completed: "completed";
//    readonly Rejected: "rejected";
// }

type StatusType = typeof Status[keyof typeof Status]; // 'pending' | 'in_progress' | 'completed' | 'rejected'

function processStatus(status: StatusType) {
  console.log(`Traitement du statut : ${status}`);
}

processStatus(Status.InProgress); // Valide
// processStatus('invalid'); // Erreur : L'argument de type '"invalid"' n'est pas assignable au paramètre de type 'StatusType'.

            

              
                Copy
              
            
          

Dans cet exemple, nous définissons un objet JavaScript simple avec des valeurs de chaîne. L'assertion as const indique à TypeScript de traiter cet objet comme étant en lecture seule et d'inférer les types les plus spécifiques pour ses propriétés. Nous extrayons ensuite un type d'union à partir des clés. Cette approche offre plusieurs avantages :

Avantages des Assertions de constantes

• Immuabilité : Les assertions de constantes créent des structures de données immuables, empêchant les modifications accidentelles.
• Pas de surcharge d'exécution : Ce sont de simples objets JavaScript, il n'y a donc pas de surcharge d'exécution associée aux enums.
• Sécurité de type : Elles offrent une forte sécurité de type en restreignant les valeurs aux constantes définies.
• Compatible avec le tree-shaking : Les bundlers modernes peuvent facilement éliminer les valeurs inutilisées (tree-shake), réduisant ainsi la taille du bundle.

Considérations pour les Assertions de constantes

• Plus verbeux : La définition et le typage peuvent être légèrement plus verbeux que pour les enums, surtout pour les cas simples.
• Pas de mappage inversé : Elles ne fournissent pas de mappage inversé, mais c'est souvent un avantage plutôt qu'un inconvénient.

Alternative 2 : Types d'union

Les types d'union vous permettent de définir une variable qui peut contenir l'un des plusieurs types possibles. C'est une manière plus directe de définir les valeurs autorisées sans objet, ce qui est avantageux lorsque vous n'avez pas besoin de la relation clé-valeur d'un enum ou d'une assertion de constante.

            
type Status = 'pending' | 'in_progress' | 'completed' | 'rejected';

function processStatus(status: Status) {
  console.log(`Traitement du statut : ${status}`);
}

processStatus('in_progress'); // Valide
// processStatus('invalid'); // Erreur : L'argument de type '"invalid"' n'est pas assignable au paramètre de type 'Status'.

            

              
                Copy
              
            
          

C'est une manière concise et sécurisée en termes de types de définir un ensemble de valeurs autorisées.

Avantages des Types d'union

• Concision : Les types d'union sont l'approche la plus concise, en particulier pour les ensembles simples de constantes de type chaîne ou numérique.
• Sécurité de type : Ils offrent une forte sécurité de type en restreignant les valeurs aux options définies.
• Pas de surcharge d'exécution : Les types d'union n'existent qu'au moment de la compilation et n'ont pas de représentation à l'exécution.

Considérations pour les Types d'union

• Pas d'association Clé-Valeur : Ils ne fournissent pas de relation clé-valeur comme les enums ou les assertions de constantes. Cela signifie que vous ne pouvez pas facilement rechercher une valeur par son nom.
• Répétition de littéraux de chaîne : Vous pourriez avoir besoin de répéter des littéraux de chaîne si vous utilisez le même ensemble de valeurs à plusieurs endroits. Cela peut être atténué avec une définition de `type` partagée.

Quand utiliser quelle approche ?

La meilleure approche dépend de vos besoins et priorités spécifiques. Voici un guide pour vous aider à choisir :

• Utilisez les Enums lorsque :
  • Vous avez besoin d'un ensemble simple de constantes numériques avec incrémentation implicite.
  • Vous avez besoin d'un mappage inversé (bien que cela soit rarement nécessaire).
  • Vous travaillez avec du code hérité qui utilise déjà des enums de manière extensive et vous n'avez pas de besoin pressant de le modifier.
• Utilisez les Assertions de constantes lorsque :
  • Vous avez besoin d'un ensemble de constantes de type chaîne ou numérique qui doivent être immuables.
  • Vous avez besoin d'une relation clé-valeur et souhaitez éviter la surcharge d'exécution.
  • Le tree-shaking et la taille du bundle sont des considérations importantes.
• Utilisez les Types d'union lorsque :
  • Vous avez besoin d'une manière simple et concise de définir un ensemble de valeurs autorisées.
  • Vous n'avez pas besoin d'une relation clé-valeur.
  • Les performances et la taille du bundle sont critiques.

Scénario d'exemple : Définir des rôles d'utilisateur

Considérons un scénario où vous devez définir des rôles d'utilisateur dans une application. Vous pourriez avoir des rôles comme "Admin", "Editor" et "Viewer".

Utilisation des Enums :

            
enum UserRole {
  Admin,
  Editor,
  Viewer,
}

function authorize(role: UserRole) {
  // ...
}

            

              
                Copy
              
            
          

Utilisation des Assertions de constantes :

            
const UserRole = {
  Admin: 'admin',
  Editor: 'editor',
  Viewer: 'viewer',
} as const;

type UserRoleType = typeof UserRole[keyof typeof UserRole];

function authorize(role: UserRoleType) {
  // ...
}

            

              
                Copy
              
            
          

Utilisation des Types d'union :

            
type UserRole = 'admin' | 'editor' | 'viewer';

function authorize(role: UserRole) {
  // ...
}

            

              
                Copy
              
            
          

Dans ce scénario, les types d'union offrent la solution la plus concise et la plus efficace. Les assertions de constantes sont une bonne alternative si vous préférez une relation clé-valeur, peut-être pour rechercher des descriptions de chaque rôle. Les enums ne sont généralement pas recommandées ici, à moins que vous n'ayez un besoin spécifique de valeurs numériques ou de mappage inversé.

Scénario d'exemple : Définir les codes de statut des points de terminaison API

Considérons un scénario où vous devez définir les codes de statut des points de terminaison API. Vous pourriez avoir des codes comme 200 (OK), 400 (Requête incorrecte), 401 (Non autorisé) et 500 (Erreur interne du serveur).

Utilisation des Enums :

            
enum StatusCode {
  OK = 200,
  BadRequest = 400,
  Unauthorized = 401,
  InternalServerError = 500
}

function processStatus(code: StatusCode) {
  // ...
}

            

              
                Copy
              
            
          

Utilisation des Assertions de constantes :

            
const StatusCode = {
  OK: 200,
  BadRequest: 400,
  Unauthorized: 401,
  InternalServerError: 500
} as const;

type StatusCodeType = typeof StatusCode[keyof typeof StatusCode];

function processStatus(code: StatusCodeType) {
  // ...
}

            

              
                Copy
              
            
          

Utilisation des Types d'union :

            
type StatusCode = 200 | 400 | 401 | 500;

function processStatus(code: StatusCode) {
  // ...
}

            

              
                Copy
              
            
          

Encore une fois, les types d'union offrent la solution la plus concise et la plus efficace. Les assertions de constantes sont une alternative solide et peuvent être préférées car elles fournissent une description plus verbeuse pour un code de statut donné. Les enums pourraient être utiles si des bibliothèques externes ou des API attendent des codes de statut basés sur des entiers, et que vous souhaitez assurer une intégration transparente. Les valeurs numériques s'alignent avec les codes HTTP standard, ce qui peut simplifier l'interaction avec les systèmes existants.

Considérations de performance

Dans la plupart des cas, la différence de performance entre les enums, les assertions de constantes et les types d'union est négligeable. Cependant, dans les applications critiques en termes de performance, il est important d'être conscient des différences potentielles.

• Enums : Les enums introduisent une surcharge d'exécution due à la création d'objets JavaScript. Cette surcharge peut être significative dans les grandes applications comportant de nombreux enums.
• Assertions de constantes : Les assertions de constantes n'ont pas de surcharge d'exécution. Ce sont de simples objets JavaScript qui sont traités en lecture seule par TypeScript.
• Types d'union : Les types d'union n'ont pas de surcharge d'exécution. Ils n'existent qu'au moment de la compilation et sont effacés pendant la compilation.

Si la performance est une préoccupation majeure, les types d'union sont généralement le meilleur choix. Les assertions de constantes sont également une bonne option, surtout si vous avez besoin d'une relation clé-valeur. Évitez d'utiliser les enums dans les sections critiques de votre code en termes de performance, à moins d'avoir une raison spécifique de le faire.

Implications Globales et Bonnes Pratiques

Lorsque vous travaillez sur des projets avec des équipes internationales ou des utilisateurs mondiaux, il est crucial de prendre en compte la localisation et l'internationalisation. Voici quelques bonnes pratiques pour l'utilisation des enums et de leurs alternatives dans un contexte global :

• Utilisez des noms descriptifs : Choisissez des noms de membres d'enum (ou des clés d'assertion de constante) qui sont clairs et non ambigus, même pour les non-anglophones. Évitez l'argot ou le jargon.
• Considérez la localisation : Si vous devez afficher les noms des membres d'enum aux utilisateurs, envisagez d'utiliser une bibliothèque de localisation pour fournir des traductions pour différentes langues. Par exemple, au lieu d'afficher directement `Status.InProgress`, vous pourriez afficher `i18n.t('status.in_progress')`.
• Évitez les hypothèses spécifiques à une culture : Soyez attentif aux différences culturelles lors de la définition des valeurs d'enum. Par exemple, les formats de date, les symboles monétaires et les unités de mesure peuvent varier considérablement d'une culture à l'autre. Si vous devez représenter ces valeurs, envisagez d'utiliser une bibliothèque qui gère la localisation et l'internationalisation.
• Documentez votre code : Fournissez une documentation claire et concise pour vos enums et leurs alternatives, expliquant leur but et leur utilisation. Cela aidera les autres développeurs à comprendre votre code, quel que soit leur parcours ou leur expérience.

Exemple : Localisation des rôles d'utilisateur

Revenons à l'exemple des rôles d'utilisateur et examinons comment localiser les noms de rôles pour différentes langues.

            
// Utilisation des assertions de constantes avec la localisation
const UserRole = {
  Admin: 'admin',
  Editor: 'editor',
  Viewer: 'viewer',
} as const;

type UserRoleType = typeof UserRole[keyof typeof UserRole];

// Fonction de localisation (utilisant une bibliothèque i18n hypothétique)
function getLocalizedRoleName(role: UserRoleType, locale: string): string {
  switch (role) {
    case UserRole.Admin:
      return i18n.t('user_role.admin', { locale });
    case UserRole.Editor:
      return i18n.t('user_role.editor', { locale });
    case UserRole.Viewer:
      return i18n.t('user_role.viewer', { locale });
    default:
      return 'Rôle Inconnu';
  }
}

// Exemple d'utilisation
const currentRole: UserRoleType = UserRole.Editor;
const localizedRoleName = getLocalizedRoleName(currentRole, 'fr-CA'); // Retourne "Éditeur" localisé pour le français canadien.
console.log(`Rôle actuel : ${localizedRoleName}`);

            

              
                Copy
              
            
          

Dans cet exemple, nous utilisons une fonction de localisation pour récupérer le nom de rôle traduit en fonction du locale de l'utilisateur. Cela garantit que les noms de rôles sont affichés dans la langue préférée de l'utilisateur.

Conclusion

Les enums TypeScript sont une fonctionnalité utile, mais ce n'est pas toujours le meilleur choix. Les assertions de constantes et les types d'union offrent des alternatives viables qui peuvent fournir de meilleures performances, une meilleure immuabilité et une meilleure maintenabilité du code. En comprenant les avantages et les inconvénients de chaque approche, vous pouvez prendre des décisions éclairées sur celle à utiliser dans vos projets. Tenez compte des besoins spécifiques de votre application, des préférences de votre équipe et de la maintenabilité à long terme de votre code. En pesant soigneusement ces facteurs, vous pouvez choisir la meilleure approche pour définir des constantes dans vos projets TypeScript, ce qui mènera à des bases de code plus propres, plus efficaces et plus faciles à maintenir.